/*
    * Copyright (C) 2011 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect;
  
  import static java.util.concurrent.TimeUnit.HOURS;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.base.Function;
  
  import junit.framework.TestCase;
  
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  /**
   * @author Charles Fry
   */
  @GwtCompatible(emulated = true)
  public class MapMakerTest extends TestCase {
  
    // "Basher tests", where we throw a bunch of stuff at a Cache and check basic invariants.
  
    /*
     * TODO(cpovirk): eliminate duplication between these tests and those in LegacyMapMakerTests and
     * anywhere else
     */
  
    /** Tests for the builder. */
    public static class MakerTest extends TestCase {
      public void testInitialCapacity_negative() {
        MapMaker maker = new MapMaker();
        try {
          maker.initialCapacity(-1);
          fail();
        } catch (IllegalArgumentException expected) {
        }
      }
  
      // TODO(cpovirk): enable when ready
      public void xtestInitialCapacity_setTwice() {
        MapMaker maker = new MapMaker().initialCapacity(16);
        try {
          // even to the same value is not allowed
          maker.initialCapacity(16);
          fail();
        } catch (IllegalArgumentException expected) {
        }
      }
  
      @SuppressWarnings("deprecation") // test of deprecated method
      public void testExpiration_setTwice() {
        MapMaker maker = new MapMaker().expireAfterWrite(1, HOURS);
        try {
          // even to the same value is not allowed
          maker.expireAfterWrite(1, HOURS);
          fail();
        } catch (IllegalStateException expected) {
        }
      }
  
      public void testMaximumSize_setTwice() {
        MapMaker maker = new MapMaker().maximumSize(16);
        try {
          // even to the same value is not allowed
          maker.maximumSize(16);
          fail();
        } catch (IllegalStateException expected) {
        }
      }
  
      public void testReturnsPlainConcurrentHashMapWhenPossible() {
        Map<?, ?> map = new MapMaker()
            .initialCapacity(5)
            .makeMap();
        assertTrue(map instanceof ConcurrentHashMap);
      }
    }
  
    /** Tests of the built map with maximumSize. */
    public static class MaximumSizeTest extends TestCase {
      public void testPut_sizeIsZero() {
        ConcurrentMap<Object, Object> map =
            new MapMaker().maximumSize(0).makeMap();
        assertEquals(0, map.size());
       map.put(new Object(), new Object());
       assertEquals(0, map.size());
     }
 
     public void testSizeBasedEviction() {
       int numKeys = 10;
       int mapSize = 5;
       ConcurrentMap<Object, Object> map =
           new MapMaker().maximumSize(mapSize).makeMap();
       for (int i = 0; i < numKeys; i++) {
         map.put(i, i);
       }
       assertEquals(mapSize, map.size());
       for (int i = numKeys - mapSize; i < mapSize; i++) {
         assertTrue(map.containsKey(i));
       }
     }
   }
 
   /** Tests for recursive computation. */
   public static class RecursiveComputationTest extends TestCase {
     Function<Integer, String> recursiveComputer
         = new Function<Integer, String>() {
       @Override
       public String apply(Integer key) {
         if (key > 0) {
           return key + ", " + recursiveMap.get(key - 1);
         } else {
           return "0";
         }
       }
     };
 
     ConcurrentMap<Integer, String> recursiveMap = new MapMaker()
         .makeComputingMap(recursiveComputer);
 
     public void testRecursiveComputation() {
       assertEquals("3, 2, 1, 0", recursiveMap.get(3));
     }
   }
 
   /**
    * Tests for computing functionality.
    */
   public static class ComputingTest extends TestCase {
     public void testComputerThatReturnsNull() {
       ConcurrentMap<Integer, String> map = new MapMaker()
           .makeComputingMap(new Function<Integer, String>() {
             @Override
             public String apply(Integer key) {
               return null;
             }
           });
       try {
         map.get(1);
         fail();
       } catch (NullPointerException e) { /* expected */ }
     }
 
     public void testRuntimeException() {
       final RuntimeException e = new RuntimeException();
 
       ConcurrentMap<Object, Object> map = new MapMaker().makeComputingMap(
           new Function<Object, Object>() {
         @Override
         public Object apply(Object from) {
           throw e;
         }
       });
 
       try {
         map.get(new Object());
         fail();
       } catch (ComputationException ce) {
         assertSame(e, ce.getCause());
       }
     }
   }
 }